/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package gruppenkalenderProjekt.kalenderinterface;

import com.toedter.calendar.JDateChooser;
import gruppenkalenderProjekt.data.Benutzer;
import gruppenkalenderProjekt.data.Kalender;
import gruppenkalenderProjekt.data.Kalendereintrag;
import gruppenkalenderProjekt.data.Kategorie;
import java.awt.BorderLayout;
import java.awt.Container;
import java.awt.Dimension;
import java.awt.FlowLayout;
import java.rmi.RemoteException;
import java.sql.Date;
import java.sql.Time;
import java.util.Calendar;
import java.util.Vector;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.swing.BorderFactory;
import javax.swing.JButton;
import javax.swing.JCheckBox;
import javax.swing.JComboBox;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JOptionPane;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JTextArea;
import javax.swing.JTextField;
import javax.swing.JTree;
import javax.swing.event.TreeSelectionEvent;
import javax.swing.event.TreeSelectionListener;
import javax.swing.tree.DefaultMutableTreeNode;
import javax.swing.tree.DefaultTreeModel;
import javax.swing.tree.TreeSelectionModel;
import layout.TableLayout;

/**
 *
 * @author Gruppe 2
 */
class Editor implements TreeSelectionListener {
    // Interfaceclient starten bzw. Verbindung zur Verwaltung herstellen

    //Variablen um unterscheiden zu koennen ob ein neuer Eintrag angelegt werden soll
    //oder ob ein existierende editiert wird
    public static final int MODUS_UPDATE = 1000;
    public static final int MODUS_NEU = 2000;
    private int modus;
    private InterfaceClient ic;
    //Strings initiieren
    private static String frameString = "Gruppenkalender Login";
    private static String titelString = "Titel";
    private static String ortString = "Ort";
    private static String uhrString = "Uhr";
    private static String kategorieString = "Kategorie";
    private static String vonString = "von";
    private static String bisString = "bis";
    private static String zeitString = "Zeit";
    private static String erinnerungString = "Erinnerung";
    private static String alarmString = "Alarm";
    private static String beschreibungString = "Beschreibung";
    private static String speichernButtonString = "Speichern";
    private static String abbrechenButtonString = "Schließen";
    private static String neuButtonString = "Neu";
    private static String loeschenButtonString = "Löschen";
    private static String folgeterminString = "Folgetermin";
    private static String kalenderString = "Kalender";
    private static String wiederHolungString = "Wiederholung";
    private int[] erinnerungsZeiten = {1, 5, 10, 15,
        30, 45, 60, 120, 180};
    //Labels, Textfelder und Buttons initiieren
    final JLabel titel = new JLabel(titelString);
    final JLabel ort = new JLabel(ortString);
    final JLabel kategorie = new JLabel(kategorieString);
    final JLabel von = new JLabel(vonString);
    final JLabel bis = new JLabel(bisString);
    final JLabel zeit = new JLabel(zeitString);
    final JLabel zeit2 = new JLabel(zeitString);
    final JLabel uhr = new JLabel(uhrString);
    final JLabel uhr2 = new JLabel(uhrString);
    final JLabel folgetermin = new JLabel(folgeterminString);
    final JLabel kalender = new JLabel(kalenderString);
    final JLabel erinnerung = new JLabel(erinnerungString);
    final JLabel beschreibung = new JLabel(beschreibungString);
    final JLabel wiederholung = new JLabel(wiederHolungString);
    final JButton speichernButton = new JButton(speichernButtonString);
    final JButton abbrechenButton = new JButton(abbrechenButtonString);
    final JButton neuButton = new JButton(neuButtonString);
    final JButton loeschenButton = new JButton(loeschenButtonString);
    final JTextField titelTextField = new JTextField(25);
    final JTextField ortTextField = new JTextField(25);
    final JTextArea beschreibungTextArea = new JTextArea("", 1, 1);
    final JScrollPane scrollPaneBeschreibungTextArea = new JScrollPane(beschreibungTextArea);
    private JTree übersichtsBaum = new JTree();
    private JDateChooser dateChooserStart = new JDateChooser(); //Date Chooser fuer Datumsauswahl
    private JDateChooser dateChooserEnde = new JDateChooser(); //Befindet sich in extra .jar
    final JCheckBox alarmCheckBox = new JCheckBox(alarmString);
    final JComboBox kategorieComboBox = new JComboBox();
    final JComboBox wiederholungComboBox = new JComboBox();
    final JComboBox vonMinutenComboBox = new JComboBox();
    final JComboBox vonStundenComboBox = new JComboBox();
    final JComboBox bisMinutenComboBox = new JComboBox();
    final JComboBox bisStundenComboBox = new JComboBox();
    final JComboBox erinnerungComboBox = new JComboBox();
    final JComboBox kalenderComboBox = new JComboBox();
    final JComboBox folgeterminComboBox = new JComboBox();
    private JCheckBox[] checkBoxContainer = new JCheckBox[14];                  // CheckBox-Array zum Sammeln der Kalendernutzernamen. Auf 14 gefixt, da sonst der Platz im Teilnehmerfeld scrollbar gemacht werden müsste -> Wäre unschön. Ich denke 14 Teilnehmer reichen vollkommen erstmal aus.
    JFrame frame = new JFrame(frameString);
    private Vector<Kalender> alleKalender;
    private Kalendereintrag aktuellerKalendereintrag = null;
    private Vector<Kategorie> alleKategorien;
    private Benutzer aktuellerBenutzer;

    public JPanel generateComponents(GruppenkalenderInterface gki) throws RemoteException {

        ic = gki.getIC();

        // Layout und Container initiieren
        aktuellerBenutzer = gki.getAktuellerBenutzer();
        //Lese die Benutzer des Kalenders aus und setze die Benutzernamen als Checkboxen

        //Anpassen der Ansicht an den eingeloggten Benutzer. unterscheidung zwischen Superuser + normaler Benutzer
        if (!aktuellerBenutzer.isSuperbenutzer()) {
            alleKalender = ic.getAlleKalenderVonBenutzer(aktuellerBenutzer.getBenutzerID());
        } else {
            alleKalender = ic.getAlleKalender(); //Ein Superbenutzer sieht alle Einträge!
        }


        modus = Editor.MODUS_NEU;
        Container contentPane = frame.getContentPane();
        BorderLayout layout = new BorderLayout();
        contentPane.setLayout(layout);


        // Panels
        // Das Panel wird mit einem TableLayout initialisiert.
        double sizeBig[][] = {{160, 15, 275, 15, 290}, // Columns              Breite jeder Spalte (Komischerweise wird nur eine Spalte alleine nicht gesetzt)
            {475}};                                               // Rows                 Höhe jeder Zeile (35=Buttongröße, 15=Leerzeile)

        JPanel big = new JPanel(new TableLayout(sizeBig));
        big.setBorder(
                BorderFactory.createCompoundBorder(
                BorderFactory.createTitledBorder("Kalendereintrag erstellen"),
                BorderFactory.createEmptyBorder(5, 5, 5, 5)));


        // Center Panel: Titel, Ort und Kategorie
        double sizeDate[][] = {{80, 195}, // Columns             275 Breite jeder Spalte (Komischerweise wird nur eine Spalte alleine nicht gesetzt)
            {30, 8, 30, 8, 30, 8, 30}};                             // Rows                 Höhe jeder Zeile (35=Buttongröße, 15=Leerzeile)

        JPanel panelForDate = new JPanel(new TableLayout(sizeDate));

        JPanel panelForZeitVon = new JPanel(new FlowLayout(FlowLayout.LEFT));
        panelForZeitVon.add(vonStundenComboBox);
        panelForZeitVon.add(new JLabel(":"));
        panelForZeitVon.add(vonMinutenComboBox);
        panelForZeitVon.add(uhr);

        JPanel panelForZeitBis = new JPanel(new FlowLayout(FlowLayout.LEFT));
        panelForZeitBis.add(bisStundenComboBox);
        panelForZeitBis.add(new JLabel(":"));
        panelForZeitBis.add(bisMinutenComboBox);
        panelForZeitBis.add(uhr2);
        //0-23 Uhr fuellen
        for (int i = 0; i < 24; i++) {
            vonStundenComboBox.addItem(i);
            bisStundenComboBox.addItem(i);
        }
        //0-59 Minuten fuellen
        for (int i = 0; i < 60; i++) {
            vonMinutenComboBox.addItem(i);
            bisMinutenComboBox.addItem(i);
        }

        //Kalendernamen in das DropDown schreiben
        for (int i = 0; i < alleKalender.size(); i++) {
            kalenderComboBox.addItem(alleKalender.elementAt(i).getName());
        }

        folgeterminComboBox.addItem("Nein");
        for (int i = 0; i < alleKalender.size(); i++) {
            for (int j = 0; j < alleKalender.elementAt(i).getKalendereintraege().size(); j++) {
                folgeterminComboBox.addItem(alleKalender.elementAt(i).getKalendereintraege().elementAt(j).getTitel());
            }
        }
        wiederholungComboBox.addItem("Nein");
        wiederholungComboBox.addItem("Wöchentlich");
        wiederholungComboBox.addItem("Monatlich");
        wiederholungComboBox.addItem("Jährlich");


        double sizeFolgeterminKalender[][] = {{80, 195}, // Columns             275 Breite jeder Spalte (Komischerweise wird nur eine Spalte alleine nicht gesetzt)
            {30, 10, 30, 10, 30}};

        JPanel panelForFolgeterminKalender = new JPanel(new TableLayout(sizeFolgeterminKalender));
        panelForFolgeterminKalender.add(folgetermin, "0, 0");
        panelForFolgeterminKalender.add(folgeterminComboBox, "1, 0");
        panelForFolgeterminKalender.add(wiederholung, "0, 2");
        panelForFolgeterminKalender.add(wiederholungComboBox, "1, 2");
        panelForFolgeterminKalender.add(kalender, "0, 4");
        panelForFolgeterminKalender.add(kalenderComboBox, "1, 4");

        JPanel center = new JPanel(new FlowLayout());
        center.setPreferredSize(new Dimension(325, 500));                      // width, height
        JPanel right = new JPanel(new BorderLayout());



        double sizeForÜbersichtsbaum[][] = {{130}, // Columns             275 Breite jeder Spalte (Komischerweise wird nur eine Spalte alleine nicht gesetzt)
            {430}};                             // Rows                 Höhe jeder Zeile (35=Buttongröße, 15=Leerzeile)
        JPanel panelForübersichtsBaum = new JPanel(new TableLayout(sizeForÜbersichtsbaum));
        panelForübersichtsBaum.setBorder(
                BorderFactory.createCompoundBorder(
                BorderFactory.createTitledBorder("Kalenderübersicht"),
                BorderFactory.createEmptyBorder(1, 1, 1, 1)));

        center.setPreferredSize(new Dimension(145, 500));                      // width, height
        // Center Panel: Titel, Ort und Kategorie
        double sizeTitel[][] = {{80, 195}, // Columns             275 Breite jeder Spalte (Komischerweise wird nur eine Spalte alleine nicht gesetzt)
            {30, 10, 30, 10, 30}};                             // Rows                 Höhe jeder Zeile (35=Buttongröße, 15=Leerzeile)

        JPanel panelForTitelOrtKategorie = new JPanel(new TableLayout(sizeTitel));

        // Center Panel: Von, Bis Erinnerung Alarm
        double sizeErinnerung[][] = {{80, 72, 5, 50, 67}, // Columns             275 Breite jeder Spalte (Komischerweise wird nur eine Spalte alleine nicht gesetzt)
            {30, 10}};                             // Rows                 Höhe jeder Zeile (35=Buttongröße, 15=Leerzeile)
        JPanel panelForErinnerung = new JPanel(new TableLayout(sizeErinnerung));

        // Right Panel: Beschreibung
        double sizeBeschreibung[][] = {{262}, // Columns             275 Breite jeder Spalte (Komischerweise wird nur eine Spalte alleine nicht gesetzt)
            {160}};                                        // Rows                 Höhe jeder Zeile (35=Buttongröße, 15=Leerzeile)
        JPanel panelForBeschreibung = new JPanel(new TableLayout(sizeBeschreibung));
        panelForBeschreibung.setBorder(
                BorderFactory.createCompoundBorder(
                BorderFactory.createTitledBorder("Beschreibung"),
                BorderFactory.createEmptyBorder(0, 0, 0, 0)));
        beschreibungTextArea.setLineWrap(true);
        beschreibungTextArea.setWrapStyleWord(true);

        // Right Panel: Teilnehmer
        double sizeTeilnehmer[][] = {{121, 10, 121}, // Columns             275 Breite jeder Spalte (Komischerweise wird nur eine Spalte alleine nicht gesetzt)
            //           0   1   2   3   4   5   6   7
            {25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25}};           // Rows                 Höhe jeder Zeile (35=Buttongröße, 15=Leerzeile)

        JPanel panelForTeilnehmer = new JPanel(new TableLayout(sizeTeilnehmer));

        panelForTeilnehmer.setBorder(
                BorderFactory.createCompoundBorder(
                BorderFactory.createTitledBorder("Teilnehmer des Termins festlegen"),
                BorderFactory.createEmptyBorder(5, 5, 5, 5)));




        double sizeButtons[][] = {{340, 100, 10, 100, 10, 100, 10, 100}, // Columns             275 Breite jeder Spalte (Komischerweise wird nur eine Spalte alleine nicht gesetzt)
            {25}};           // Rows                 Höhe jeder Zeile (35=Buttongröße, 15=Leerzeile)

        JPanel panelForSpeicherAbbrechen = new JPanel(new TableLayout(sizeButtons));


        //Die Erinnerungszeiten, die als Attribut definiert sind, werden der ComoBox hinzugefuegt
        erinnerungComboBox.addItem("Nein");
        for (int i = 0; i < erinnerungsZeiten.length; i++) {
            erinnerungComboBox.addItem(erinnerungsZeiten[i]);
        }

        //Alle Kategorien aus der DB werden der zugehoerigen ComoBox hinzugefuegt
        alleKategorien = ic.getAlleKategorien();
        for (int i = 0; i < alleKategorien.size(); i++) {
            kategorieComboBox.addItem(alleKategorien.elementAt(i).getBezeichnung());

        }

        createJTree();

        /* Hier muss jetzt eigentlich der JTree aufgebaut werden, man kennt ja nun
         * Den aktuellen Benutzer und alle Seine Kalender
         * Von den Kalendern wei‚àö√º man die Kalendereintraege
         * von den Kalendereintraegen wei‚àö√º man die Teilnehmer
         * Man wei‚àö√º im Prinzip alles
         * Dann muss irgendwie ein Eintrag im JTree vorselektiert werden, und der
         * kann dann im folgenden angezeigt werden
         * */
//
//        for (int j = 0; j < tempKalender.size(); j++) {
//
        //Liest alle Benutzer aus, die den Kalender sehen!
        Vector<Benutzer> alleBenutzer = ic.getAlleBenutzer();
        for (int i = 0; i < alleBenutzer.size(); i++) {
            String Benutzername = alleBenutzer.elementAt(i).getBenutzername();
            final JCheckBox check = new JCheckBox(Benutzername);
            if (i % 2 == 0) {
                panelForTeilnehmer.add(check, "0," + i);
                checkBoxContainer[i] = check;
            } else {
                panelForTeilnehmer.add(check, "2," + (i - 1));
                checkBoxContainer[i] = check;
            }
        }


        übersichtsBaum.setBorder(null);

        übersichtsBaum.getSelectionModel().setSelectionMode(
                TreeSelectionModel.SINGLE_TREE_SELECTION);

        übersichtsBaum.addTreeSelectionListener(this);
        System.out.println("Listener angemeldet");
        JPanel left = new JPanel(new FlowLayout());
        final JScrollPane scrollPaneübersichtsBaum = new JScrollPane(übersichtsBaum);


        //OnButtonClick
        loeschenButton.addActionListener(gki);
        loeschenButton.setActionCommand("LoescheKalendereintrag");
        //OnButtonClick
        neuButton.addActionListener(gki);
        neuButton.setActionCommand("NeuerKalendereintrag");
        //OnButtonClick
        speichernButton.addActionListener(gki);
        speichernButton.setActionCommand("SpeicherKalendereintrag");
        //OnButtonClick
        abbrechenButton.addActionListener(gki);
        abbrechenButton.setActionCommand("Abbrechen");

        // LAYOUT PANEL

        panelForübersichtsBaum.add(scrollPaneübersichtsBaum, "0,0");

        panelForTitelOrtKategorie.add(titel, "0, 0");                          //col,row
        panelForTitelOrtKategorie.add(titelTextField, "1, 0");
        panelForTitelOrtKategorie.add(ort, "0, 2");
        panelForTitelOrtKategorie.add(ortTextField, "1, 2");
        panelForTitelOrtKategorie.add(kategorie, "0, 4");
        panelForTitelOrtKategorie.add(kategorieComboBox, "1, 4");


        panelForDate.add(von, "0, 0");
        panelForDate.add(dateChooserStart, "1, 0");
        panelForDate.add(zeit, "0, 2");
        panelForDate.add(panelForZeitVon, "1, 2");
        panelForDate.add(bis, "0, 4");
        panelForDate.add(dateChooserEnde, "1, 4");
        panelForDate.add(zeit2, "0, 6");
        panelForDate.add(panelForZeitBis, "1, 6");

        panelForErinnerung.add(erinnerung, "0, 0");
        panelForErinnerung.add(erinnerungComboBox, "1, 0");
        panelForErinnerung.add(alarmCheckBox, "4, 0");


        panelForBeschreibung.add(scrollPaneBeschreibungTextArea, "0, 0");




        panelForSpeicherAbbrechen.add(neuButton, "1,0");
        panelForSpeicherAbbrechen.add(speichernButton, "3,0");
        panelForSpeicherAbbrechen.add(loeschenButton, "5,0");
        panelForSpeicherAbbrechen.add(abbrechenButton, "7,0");




        // PANELS ZUR UNTERTEILUNG
        left.add(panelForübersichtsBaum);
        center.add(panelForTitelOrtKategorie);
        center.add(panelForDate); //Neu
        center.add(panelForErinnerung);
        center.add(panelForFolgeterminKalender);
        right.add(panelForBeschreibung, BorderLayout.NORTH);
        right.add(panelForTeilnehmer, BorderLayout.WEST);
        big.add(panelForSpeicherAbbrechen, BorderLayout.SOUTH);


        // BIG PANEL
        big.add(left, "0, 0");
        big.add(center, "2, 0");
        big.add(right, "4, 0");


        contentPane.add(big, BorderLayout.NORTH);
        contentPane.add(panelForSpeicherAbbrechen, BorderLayout.SOUTH);

        return (JPanel) contentPane;
    }

    private void createJTree() {

        übersichtsBaum.removeAll();

        //oberste Element
        DefaultMutableTreeNode top = new DefaultMutableTreeNode("Kalender");

        //Erste Ebene mit Kalendern erzeugen
        for (int i = 0; i < alleKalender.size(); i++) {
            DefaultMutableTreeNode kalender = null; //lokaler Speicher
            try {
                //Kalendername wir als eigenenr Knoten in Schleife erzeugt
                kalender = new DefaultMutableTreeNode(alleKalender.elementAt(i).getName());
            } catch (RemoteException ex) {
                ex.printStackTrace();
            }
            //Knoten dem obersten Element hinzufuegen
            top.add(kalender);
            try {
                //alle Kalendereintraege eines Kalenders zwischenspeichern
                Vector<Kalendereintrag> kalendereintraege = alleKalender.elementAt(i).getKalendereintraege();
                for (int j = 0; j < kalendereintraege.size(); j++) {
                    DefaultMutableTreeNode kalendereintrag = null;
                    kalendereintrag = new DefaultMutableTreeNode(kalendereintraege.elementAt(j).getTitel());
                    kalender.add(kalendereintrag);
                    //Kalendereintrag als Zweite Ebene erzeugen (auch in Schleife)
                }
            } catch (RemoteException ex) {
                ex.printStackTrace();
            }
        }
        //JTree anlegen

        übersichtsBaum = new JTree(top);
    }

    private void zeigeKalendereintrag(Kalendereintrag temp) {
        aktuellerKalendereintrag = temp;

        try {
            //Titel setzen
            beschreibungTextArea.setText(temp.getBeschreibung());
            //Ort setzen
            ortTextField.setText(temp.getOrt());
            //titel setzen
            titelTextField.setText(temp.getTitel());
            //erinnerung setzen
            if (!temp.isErinnerung()) {
                erinnerungComboBox.setSelectedItem("Nein");
            } else {
                erinnerungComboBox.setSelectedItem(temp.getZeitdifferenzErinnerung());
            }
            //alarm setzen
            if (temp.isAlarm()) {
                alarmCheckBox.setSelected(true);
            } else {
                alarmCheckBox.setSelected(false);
            }
            //kategorie vorselektieren
            kategorieComboBox.setSelectedItem(temp.getKategorie().getBezeichnung());
            //Datum setzen
            dateChooserEnde.setDate(temp.getEnddatum());
            dateChooserStart.setDate(temp.getStartdatum());


            vonStundenComboBox.setSelectedItem(temp.getStartzeit().getHours());
            vonMinutenComboBox.setSelectedItem(temp.getStartzeit().getMinutes());
            bisStundenComboBox.setSelectedItem(temp.getEndzeit().getHours());
            bisMinutenComboBox.setSelectedItem(temp.getEndzeit().getMinutes());


            for (int j = 0; j < checkBoxContainer.length; j++) {
                if (checkBoxContainer[j] != null) {
                    checkBoxContainer[j].setSelected(false);
                    for (int i = 0; i < temp.getTeilnehmer().size(); i++) {
                        if (checkBoxContainer[j].getText().equals(temp.getTeilnehmer().elementAt(i).getBenutzername())) {
                            checkBoxContainer[j].setSelected(true);
                        }
                    }
                }
            }

            for (int i = 0; i < alleKalender.size(); i++) {
                if (alleKalender.elementAt(i).getKalenderID() == temp.getKalenderID()) {
                    kalenderComboBox.setSelectedItem(alleKalender.elementAt(i).getName());
                }
            }

            wiederholungComboBox.setSelectedIndex(temp.getWiederholung());


            if (temp.getFolgetermin() != null) {
                folgeterminComboBox.setSelectedItem(temp.getFolgetermin().getTitel());
            } else {
                folgeterminComboBox.setSelectedItem("Nein");
            }




        } catch (RemoteException ex) {
            ex.printStackTrace();
        }




    }

    @Override
    public void valueChanged(TreeSelectionEvent e) {

        DefaultMutableTreeNode node = (DefaultMutableTreeNode) übersichtsBaum.getLastSelectedPathComponent();

        if (node == null) {
            return;
        }
        modus = Editor.MODUS_UPDATE;

        String auswahl = (String) node.getUserObject();

        if (node.isLeaf()) {
            System.out.println(auswahl + " ausgewaehlt");

            Vector<Kalendereintrag> kalendereintraege = null;
            for (int i = 0; i < alleKalender.size(); i++) {
                try {
                    kalendereintraege = alleKalender.elementAt(i).getKalendereintraege();
                    for (int j = 0; j < kalendereintraege.size(); j++) {
                        if (auswahl.equals(kalendereintraege.elementAt(j).getTitel())) {
                            this.zeigeKalendereintrag(kalendereintraege.elementAt(j));
                        }
                    }
                } catch (RemoteException ex) {
                    Logger.getLogger(Editor.class.getName()).log(Level.SEVERE, null, ex);
                }
            }
        } else {
            //System.out.println("Kalender ausgewaehlt: " + auswahl);
        }



    }

    public void updateAktuellenKalendereintrag() {

        switch (modus) {

            case Editor.MODUS_UPDATE:
                // System.out.println("Speichern von Modus UPDATE ausgewählt");
                try {
                    aktuellerKalendereintrag.setTitel(titelTextField.getText());
                    aktuellerKalendereintrag.setBeschreibung(beschreibungTextArea.getText());
                    aktuellerKalendereintrag.setOrt(ortTextField.getText());
                    //setzt aktuell ausgewahlte Kategorie
                    for (int i = 0; i < alleKategorien.size(); i++) {
                        if (alleKategorien.elementAt(i).getBezeichnung().equals(kategorieComboBox.getSelectedItem())) {
                            aktuellerKalendereintrag.setKategorie(alleKategorien.elementAt(i));
                        }
                    }
                    if (alarmCheckBox.isSelected()) {
                        aktuellerKalendereintrag.setAlarm(true);
                    } else {
                        aktuellerKalendereintrag.setAlarm(false);
                    }
                    if (erinnerungComboBox.getSelectedItem().equals("Nein")) {
                        aktuellerKalendereintrag.setErinnerung(false);
                        aktuellerKalendereintrag.setZeitdifferenzErinnerung(0);
                    } else {
                        aktuellerKalendereintrag.setErinnerung(true);
                        //konvertiert den Wert aus der ComboBox in einen Integer und fuegt sie dem aktuellen Eintrag hinzu
                        aktuellerKalendereintrag.setZeitdifferenzErinnerung(Integer.valueOf(erinnerungComboBox.getSelectedItem().toString()));
                    }


                    aktuellerKalendereintrag.setStartdatum(new Date(dateChooserStart.getCalendar().getTime().getTime()));
                    aktuellerKalendereintrag.setEnddatum(new Date(dateChooserEnde.getCalendar().getTime().getTime()));


                    Time tempTime = new Time(0, 0, 0); //lokale Variable anlegen
                    tempTime.setHours(Integer.valueOf(vonStundenComboBox.getSelectedItem().toString())); //Der Wert der in der Dropbox
                    //steht in ein int umwandeln und dem Time Objekt hinzufuegen
                    tempTime.setMinutes(Integer.valueOf(vonMinutenComboBox.getSelectedItem().toString()));

                    aktuellerKalendereintrag.setStartzeit(tempTime); //lokale Variable dem echten Objekt hinzufuegen
                    tempTime = new Time(0, 0, 0);
                    tempTime.setHours(Integer.valueOf(bisStundenComboBox.getSelectedItem().toString()));
                    tempTime.setMinutes(Integer.valueOf(bisMinutenComboBox.getSelectedItem().toString()));
                    aktuellerKalendereintrag.setEndzeit(tempTime);

                    if (!ic.isKalendereintragStartzeitZulaessig(aktuellerKalendereintrag)) {
                        String message = (String) (("Der angegebene Start- oder Endzeitpunkt ist nicht zulässig. \n" +
                                "Die Startzeit/Startdatum muss vor (oder gleich) der Endzeit/Enddatum sein."));
                        JOptionPane.showMessageDialog(null, message, "Eingabefehler", 2, null);
                        return;
                    }




                    //liest alle selektierten Benutzer aus und fuegt sie einem Vector hinzu
                    Vector<Benutzer> temp = new Vector<Benutzer>();
                    for (int i = 0; i < checkBoxContainer.length; i++) {
                        if (checkBoxContainer[i] != null) { //abfrage ob null, da es Checboxen geben kann als Benutzer
                            if (checkBoxContainer[i].isSelected()) {
                                temp.addElement(ic.getBenutzerMitBenutzername(
                                        checkBoxContainer[i].getText())); //Wenn Checkbox selektiert, dann setze Vektor
                            }
                        }
                    }
                    aktuellerKalendereintrag.setTeilnehmer(temp);

                    for (int i = 0; i < alleKalender.size(); i++) {
                        if (alleKalender.elementAt(i).getName().equals(kalenderComboBox.getSelectedItem())) {
                            aktuellerKalendereintrag.setKalenderID(alleKalender.elementAt(i).getKalenderID());
                        }
                    }


                    for (int i = 0; i < alleKalender.size(); i++) {
                        for (int j = 0; j < alleKalender.elementAt(i).getKalendereintraege().size(); j++) {
                            if (alleKalender.elementAt(i).getKalendereintraege().elementAt(j).
                                    getTitel().equals(folgeterminComboBox.getSelectedItem())) {
                                aktuellerKalendereintrag.setFolgetermin(alleKalender.elementAt(i).getKalendereintraege().elementAt(j));
                            }
                        }

                    }
                    int wiederholung = 0;
                    if (wiederholungComboBox.getSelectedItem().equals("Wöchentlich")) {
                        wiederholung = 1;
                    }
                    if (wiederholungComboBox.getSelectedItem().equals("Monatlich")) {
                        wiederholung = 2;
                    }
                    if (wiederholungComboBox.getSelectedItem().equals("Jährlich")) {
                        wiederholung = 3;
                    }
                    aktuellerKalendereintrag.setWiederholung(wiederholung);


                    zeigeKalendereintrag(ic.updateKalendereintrag(aktuellerKalendereintrag));


                    //jTree aktualisieren
                    //Den Aktuellen Knoten (wohl eher Blatt) holen
                    DefaultMutableTreeNode node = (DefaultMutableTreeNode) übersichtsBaum.getLastSelectedPathComponent();
                    //Das Model Holen
                    DefaultTreeModel model = (DefaultTreeModel) übersichtsBaum.getModel();
                    //Den neuen Titel setzen
                    node.setUserObject(aktuellerKalendereintrag.getTitel());
                    model.nodeChanged(node);


                } catch (RemoteException ex) {
                    Logger.getLogger(Editor.class.getName()).log(Level.SEVERE, null, ex);
                }

                break;

            case Editor.MODUS_NEU:

                String titel = titelTextField.getText();
                Kategorie kategorie = null;
                for (int i = 0; i < alleKategorien.size(); i++) {
                    try {
                        if (alleKategorien.elementAt(i).getBezeichnung().equals(kategorieComboBox.getSelectedItem())) {
                            kategorie = alleKategorien.elementAt(i);
                        }
                    } catch (RemoteException ex) {
                        Logger.getLogger(Editor.class.getName()).log(Level.SEVERE, null, ex);
                    }
                }

                Benutzer ersteller = aktuellerBenutzer;
                String beschreibung = beschreibungTextArea.getText();
                String ort = ortTextField.getText();

                Date startdatum = new Date(dateChooserStart.getCalendar().getTime().getTime());
                Date enddatum = new Date(dateChooserEnde.getCalendar().getTime().getTime());
                Time startzeit = new Time(0, 0, 0);
                startzeit.setHours(Integer.valueOf(vonStundenComboBox.getSelectedItem().toString()));
                startzeit.setMinutes(Integer.valueOf(vonMinutenComboBox.getSelectedItem().toString()));
                Time endzeit = new Time(0, 0, 0);
                endzeit.setHours(Integer.valueOf(bisStundenComboBox.getSelectedItem().toString()));
                endzeit.setMinutes(Integer.valueOf(bisMinutenComboBox.getSelectedItem().toString()));


                //Ueberpruefe eigegebenes Datum

                boolean alarm = false;
                if (alarmCheckBox.isSelected()) {
                    alarm = true;
                }


                boolean erinnerung = false;
                int zeitdifferenzerinnerung = 0;

                if (!erinnerungComboBox.getSelectedItem().equals("Nein")) {
                    erinnerung = true;
                    //konvertiert den Wert aus der ComboBox in einen Integer und fuegt sie dem aktuellen Eintrag hinzu
                    zeitdifferenzerinnerung = Integer.valueOf(erinnerungComboBox.getSelectedItem().toString());
                }


                Vector<Benutzer> teilnehmer = new Vector<Benutzer>();
                for (int i = 0; i < checkBoxContainer.length; i++) {
                    if (checkBoxContainer[i] != null) {
                        if (checkBoxContainer[i].isSelected()) {
                            teilnehmer.addElement(ic.getBenutzerMitBenutzername(
                                    checkBoxContainer[i].getText()));
                        }
                    }
                }


                Kalendereintrag folgetermin = null;
                for (int i = 0; i < alleKalender.size(); i++) {
                    try {
                        for (int j = 0; j < alleKalender.elementAt(i).getKalendereintraege().size(); j++) {
                            if (alleKalender.elementAt(i).getKalendereintraege().elementAt(j).
                                    getTitel().equals(folgeterminComboBox.getSelectedItem())) {
                                folgetermin = alleKalender.elementAt(i).getKalendereintraege().elementAt(j);

                            }
                        }
                    } catch (RemoteException ex) {
                        ex.printStackTrace();
                    }
                }

                int kalender_ID = 0;
                for (int i = 0; i < alleKalender.size(); i++) {
                    try {
                        if (alleKalender.elementAt(i).getName().equals(kalenderComboBox.getSelectedItem())) {
                            kalender_ID = alleKalender.elementAt(i).getKalenderID();
                        }
                    } catch (RemoteException ex) {
                        ex.printStackTrace();
                    }
                }


                int wiederholung = 0;
                if (wiederholungComboBox.getSelectedItem().equals("Wöchentlich")) {
                    wiederholung = 1;
                }
                if (wiederholungComboBox.getSelectedItem().equals("Monatlich")) {
                    wiederholung = 2;
                }
                if (wiederholungComboBox.getSelectedItem().equals("Jährlich")) {
                    wiederholung = 3;
                }

                // die verwaltung ansprechen um ein neues Objekt zu erstellen
                // Das Objekt wird danach zurück gegeben
                aktuellerKalendereintrag = ic.createKalendereintrag(titel, kategorie, ersteller,
                        beschreibung, ort, startdatum, startzeit, enddatum, endzeit,
                        erinnerung, zeitdifferenzerinnerung, alarm, teilnehmer, folgetermin, kalender_ID, wiederholung);







                try {
                    folgeterminComboBox.addItem(aktuellerKalendereintrag.getTitel());
                } catch (RemoteException ex) {
                    ex.printStackTrace();
                }

                modus = Editor.MODUS_UPDATE;

                try {
                    alleKalender = ic.getAlleKalenderVonSuperbenutzer(aktuellerBenutzer.getBenutzerID());


                    DefaultTreeModel model = (DefaultTreeModel) übersichtsBaum.getModel();

                    DefaultMutableTreeNode root = (DefaultMutableTreeNode) model.getRoot();
                    DefaultMutableTreeNode kalender[] = new DefaultMutableTreeNode[root.getChildCount()];


                    for (int i = 0; i < kalender.length; i++) {
                        kalender[i] = (DefaultMutableTreeNode) root.getChildAt(i);
                        for (int j = 0; j < alleKalender.size(); j++) {
                            String name = (String) kalender[i].getUserObject();
                            if (alleKalender.elementAt(j).getKalenderID() == aktuellerKalendereintrag.getKalenderID()) {
                                if (name.equals(alleKalender.elementAt(j).getName())) {
                                    System.out.println("Knoten " + i + " entspricht Kalender: " + alleKalender.elementAt(j).getName() + "mit der ID :" + alleKalender.elementAt(j).getKalenderID());
                                    DefaultMutableTreeNode kalendereintrag = new DefaultMutableTreeNode(
                                            aktuellerKalendereintrag.getTitel());
                                    model.insertNodeInto(kalendereintrag, kalender[i], kalender[i].getChildCount());

                                }
                            }
                        }
                    }

                } catch (RemoteException ex) {
                    ex.printStackTrace();
                }


                break;
        }
        übersichtsBaum.requestFocus();
    }

    public void neuerKalendereintrag() {
        modus = Editor.MODUS_NEU;
        loescheAlleFelder();

    }

    public void loescheKalendereintrag() {
        try {

            //Name zwischenspeichern um den jTree zu aktualisieren
            String tempName = aktuellerKalendereintrag.getTitel();
            Kalendereintrag zuLoeschenderEintrag = aktuellerKalendereintrag;

            for (Kalender k : alleKalender) {
                for (Kalendereintrag e : k.getKalendereintraege()) {
                    if (e.getKalendereintragID() == aktuellerKalendereintrag.getKalendereintragID()) {
                        Vector<Kalendereintrag> temp = k.getKalendereintraege();
                        temp.removeElement(e);
                        k.setKalendereintraege(temp);
                    }
                }
            }

            ic.deleteKalendereintrag(zuLoeschenderEintrag);


            //jTree aktualisieren
            //Den Aktuellen Knoten (wohl eher Blatt) holen
            DefaultMutableTreeNode node = (DefaultMutableTreeNode) übersichtsBaum.getLastSelectedPathComponent();
            //Das Model Holen
            DefaultTreeModel model = (DefaultTreeModel) übersichtsBaum.getModel();
            //Den Knoten/Blatt aus dem Model entfernen.
            model.removeNodeFromParent(node);

        } catch (RemoteException ex) {
            Logger.getLogger(Editor.class.getName()).log(Level.SEVERE, null, ex);
        }



    }

    public void loescheAlleFelder() {

        //Titel setzen
        beschreibungTextArea.setText("");
        //Ort setzen
        ortTextField.setText("");
        //titel setzen
        titelTextField.setText("");
        //erinnerung setzen
        vonMinutenComboBox.setSelectedItem(0);
        vonStundenComboBox.setSelectedItem(0);
        bisMinutenComboBox.setSelectedItem(0);
        bisStundenComboBox.setSelectedItem(0);


        dateChooserEnde.setDate(Calendar.getInstance().getTime()); //heutiges Datum setzen
        dateChooserStart.setDate(Calendar.getInstance().getTime()); //heutiges Datum setzen


        erinnerungComboBox.setSelectedItem("Nein");
        wiederholungComboBox.setSelectedIndex(0);
        folgeterminComboBox.setSelectedItem("Nein");
        kalenderComboBox.setSelectedIndex(0);

        alarmCheckBox.setSelected(false);

        //Alle Teilnehmer deselektieren
        for (int j = 0; j < checkBoxContainer.length; j++) {
            if (checkBoxContainer[j] != null) {
                checkBoxContainer[j].setSelected(false);
            }
        }
    }
}

